const fetch = require('node-fetch');
const path = require('path');
const { logInfo, logError, logDebug } = require('./logger');

/**
 * 全局服务器管理器客户端
 * 连接到独立的全局管理服务器，进行服务器注册和管理
 */
class GlobalServerManager {
    constructor() {
        this.globalManagerUrl = 'http://localhost:3700'; // 全局管理服务器地址
        this.heartbeatInterval = null;
        this.registeredProjects = new Set(); // 本窗口注册的项目
        this.windowId = `window-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
        
        logDebug(`全局服务器管理器客户端已初始化，窗口ID: ${this.windowId}`);
    }

    /**
     * 确保全局管理服务器运行
     */
    async ensureGlobalManagerRunning() {
        // 首先检查是否已经运行
        try {
            const response = await fetch(`${this.globalManagerUrl}/api/global/health`, {
                timeout: 3000
            });
            
            if (response.ok) {
                logDebug('全局管理服务器已在运行');
                return true;
            }
        } catch (error) {
            // 服务器未运行，需要启动
        }
        
        logInfo('全局管理服务器未运行，尝试启动...');
        await this.startGlobalManager();
        
        // 启动后再次检查
        try {
            const response = await fetch(`${this.globalManagerUrl}/api/global/health`, {
                timeout: 5000
            });
            
            if (response.ok) {
                logInfo('全局管理服务器启动成功并可用');
                return true;
            } else {
                logError('全局管理服务器启动后健康检查失败');
                return false;
            }
        } catch (error) {
            logError('全局管理服务器启动后无法连接', error);
            return false;
        }
    }

    /**
     * 启动全局管理服务器
     */
    async startGlobalManager() {
        try {
            // 尝试启动独立的全局管理服务器
            const { spawn } = require('child_process');
            const globalManagerPath = path.join(__dirname, 'globalManager.js');
            
            const child = spawn('node', [globalManagerPath], {
                detached: true,
                stdio: 'ignore'
            });
            
            // 让子进程独立运行
            child.unref();
            
            logInfo('正在启动全局管理服务器...');
            
            // 等待服务器启动并可用，最多等待30秒
            const maxRetries = 30;
            for (let i = 0; i < maxRetries; i++) {
                await new Promise(resolve => setTimeout(resolve, 1000));
                
                try {
                    const response = await fetch(`${this.globalManagerUrl}/api/global/health`, {
                        timeout: 2000
                    });
                    
                    if (response.ok) {
                        logInfo('全局管理服务器已启动并可用');
                        return;
                    }
                } catch (checkError) {
                    // 继续等待
                }
                
                if (i % 5 === 0) {
                    logDebug(`等待全局管理服务器启动... (${i + 1}/${maxRetries})`);
                }
            }
            
            throw new Error('全局管理服务器启动超时');
            
        } catch (error) {
            logError('启动全局管理服务器失败', error);
        }
    }

    /**
     * 注册项目服务器到全局管理器
     * @param {string} projectPath 项目路径
     * @param {Object} serverInstance 服务器实例
     * @returns {number} 实际使用的端口
     */
    async registerServer(projectPath, serverInstance) {
        const port = serverInstance.getPort();
        const maxRetries = 3;
        
        for (let attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                // 确保全局管理服务器运行
                await this.ensureGlobalManagerRunning();
                
                logDebug(`尝试注册项目服务器 (${attempt}/${maxRetries}): ${path.basename(projectPath)}`);
                
                const response = await fetch(`${this.globalManagerUrl}/api/global/register`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        projectPath,
                        port,
                        windowId: this.windowId
                    }),
                    timeout: 10000
                });

                if (response.ok) {
                    const result = await response.json();
                    this.registeredProjects.add(projectPath);
                    
                    logInfo(`项目服务器已注册到全局管理器: ${path.basename(projectPath)} -> 端口 ${port}`);
                    
                    // 启动心跳
                    this.startHeartbeat();
                    
                    return port;
                } else {
                    const errorText = await response.text();
                    throw new Error(`HTTP ${response.status}: ${errorText}`);
                }
                
            } catch (error) {
                logError(`注册项目服务器失败 (尝试 ${attempt}/${maxRetries}): ${projectPath}`, error);
                
                if (attempt < maxRetries) {
                    const delay = attempt * 2000; // 递增延迟: 2s, 4s
                    logDebug(`等待 ${delay}ms 后重试...`);
                    await new Promise(resolve => setTimeout(resolve, delay));
                } else {
                    logError(`注册项目服务器最终失败: ${projectPath}，已尝试 ${maxRetries} 次`);
                }
            }
        }
        
        return port;
    }

    /**
     * 从全局管理器注销项目服务器
     * @param {string} projectPath 项目路径
     */
    async unregisterServer(projectPath) {
        try {
            const response = await fetch(`${this.globalManagerUrl}/api/global/unregister`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ projectPath }),
                timeout: 5000
            });

            if (response.ok) {
                this.registeredProjects.delete(projectPath);
                logInfo(`项目服务器已从全局管理器注销: ${path.basename(projectPath)}`);
                
                // 如果没有注册的项目了，停止心跳
                if (this.registeredProjects.size === 0) {
                    this.stopHeartbeat();
                }
            }
            
        } catch (error) {
            logError(`注销项目服务器失败: ${projectPath}`, error);
        }
    }

    /**
     * 启动心跳
     */
    startHeartbeat() {
        if (this.heartbeatInterval) {
            return; // 已经启动
        }

        // 每30秒发送一次心跳
        this.heartbeatInterval = setInterval(async () => {
            await this.sendHeartbeat();
        }, 30000);
        
        logDebug('心跳服务已启动');
    }

    /**
     * 停止心跳
     */
    stopHeartbeat() {
        if (this.heartbeatInterval) {
            clearInterval(this.heartbeatInterval);
            this.heartbeatInterval = null;
            logDebug('心跳服务已停止');
        }
    }

    /**
     * 发送心跳到全局管理器
     */
    async sendHeartbeat() {
        try {
            for (const projectPath of this.registeredProjects) {
                await fetch(`${this.globalManagerUrl}/api/global/heartbeat`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ projectPath }),
                    timeout: 3000
                });
            }
            
            logDebug(`心跳发送成功，注册项目数: ${this.registeredProjects.size}`);
            
        } catch (error) {
            logError('发送心跳失败', error);
        }
    }

    /**
     * 获取全局管理器URL
     */
    getGlobalManagerUrl() {
        return this.globalManagerUrl;
    }

    /**
     * 获取所有项目列表
     */
    async getAllProjects() {
        try {
            const response = await fetch(`${this.globalManagerUrl}/api/global/projects`, {
                timeout: 5000
            });
            
            if (response.ok) {
                const result = await response.json();
                return result.data || [];
            }
            
            return [];
        } catch (error) {
            logError('获取项目列表失败', error);
            return [];
        }
    }

    /**
     * 清理资源
     */
    async cleanup() {
        // 注销所有项目
        const projects = Array.from(this.registeredProjects);
        for (const projectPath of projects) {
            await this.unregisterServer(projectPath);
        }
        
        // 停止心跳
        this.stopHeartbeat();
        
        logInfo('全局服务器管理器客户端已清理');
    }
}

// 创建单例实例
let globalServerManagerInstance = null;

function getGlobalServerManager() {
    if (!globalServerManagerInstance) {
        globalServerManagerInstance = new GlobalServerManager();
    }
    return globalServerManagerInstance;
}

module.exports = getGlobalServerManager(); 